Importação das bibliotecas¶
In [112]:
import pandas as pd
import pandas_profiling
import numpy as np
import seaborn as sns
import sklearn
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn import model_selection
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
from sklearn.preprocessing import StandardScaler
from sklearn.dummy import DummyClassifier
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from yellowbrick.classifier import ConfusionMatrix
from yellowbrick.classifier import ROCAUC
import sklearn.metrics
from sklearn.metrics import confusion_matrix, roc_auc_score
Importação dos dados do Titanic¶
In [139]:
df = pd.read_csv(r'C:\Users\gebra\Desktop\DS\Dataset\Titanic\titanic.csv')
Visualização dos dados do Titanic¶
In [140]:
df.head()
Out[140]:
In [141]:
df.info()
In [5]:
df.shape
Out[5]:
In [6]:
pandas_profiling.ProfileReport(df)
Out[6]:
In [7]:
df.describe()
Out[7]:
Informação sobre dados categoricos¶
In [142]:
df.Sex.value_counts(dropna=False)
Out[142]:
In [143]:
df.Ticket.value_counts(dropna=False)
Out[143]:
In [144]:
df.Cabin.value_counts(dropna=False)
Out[144]:
In [145]:
df.Embarked.value_counts(dropna=False)
Out[145]:
Aquisição de titulo do nome dos individuos¶
In [146]:
nome = df["Name"].str.split(",").str.get(1)
In [147]:
df['Nome'] = nome.str.split(".").str.get(0)
In [148]:
df['Nome'].value_counts()
Out[148]:
Remoção de colunas que não serão utilizadas¶
In [149]:
df = df.drop(columns=[
"PassengerId",
"Ticket",
"Name",
"Cabin"])
In [150]:
df.head()
Out[150]:
Transformação dos dados categoricos¶
In [151]:
df = pd.get_dummies(df)
In [152]:
df.columns
Out[152]:
In [153]:
df.head()
Out[153]:
In [154]:
df.info()
In [163]:
#A coluna sex_female ja indica se a pessoa é homem ou mulher, pois isso Sex_male sera removida
df = df.drop(columns="Sex_male")
In [164]:
df = pd.get_dummies(df, drop_first=True)
In [165]:
df.columns
Out[165]:
Preparar e dividir os dados em Treino e Teste¶
In [166]:
y = df.Survived
In [167]:
X = df.drop(columns="Survived")
In [168]:
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.3, random_state=42)
In [169]:
num_cols = [
... "Pclass",
... "SibSp",
... "Parch",
... "Fare",
... "Age",
... "Sex_female",
... ]
In [170]:
X_train
Out[170]:
Tratamento de valores ausentes¶
In [171]:
X_train.isnull().sum()
Out[171]:
In [172]:
X_test.isnull().sum()
Out[172]:
In [173]:
meds = X_train.median()
X_train = X_train.fillna(meds)
X_test = X_test.fillna(meds)
In [174]:
X_train.isnull().sum()
Out[174]:
In [175]:
X_test.isnull().sum()
Out[175]:
Normalização dos dados¶
In [176]:
sca = preprocessing.StandardScaler()
X_train = sca.fit_transform(X_train)
X_test = sca.transform(X_test)
In [177]:
X_train
Out[177]:
In [178]:
X_test
Out[178]:
Treinamento e avaliação dos modelos¶
In [179]:
modelos = [DummyClassifier,
LogisticRegression,
DecisionTreeClassifier,
KNeighborsClassifier,
GaussianNB,
RandomForestClassifier,
SVC,
]
In [180]:
modelos2 = ["DummyClassifier",
"LogisticRegression",
"DecisionTreeClassifier",
"KNeighborsClassifier",
"GaussianNB",
"RandomForestClassifier",
"SVC"]
In [181]:
k = 0
for modelo in modelos:
clf = modelo()
clf.fit(X_train, y_train)
resultado = clf.score(X_test, y_test, sample_weight=None)
print (modelos2[k],":",resultado)
k += 1
In [182]:
k = 0
for modelo in modelos:
clf = modelo()
clf.fit(X_train, y_train)
prev = clf.predict(X_test)
print (modelos2[k], ":", "\n", confusion_matrix(y_test, prev), "\n")
k += 1
Curva ROC Graficamente do segundo melhor modelos¶
Nesse caso foi ultilziado o segundo modelo com a melhor acuracia, pois o SVC deu erro ao treinar com a biblioteca yellowbrick
In [183]:
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from yellowbrick.classifier import ROCAUC
from yellowbrick.datasets import load_spam
# Instantiate the visualizer with the classification model
model = LogisticRegression()
visualizer = ROCAUC(model, classes=["Morreu", "Nao Morreu"])
visualizer.fit(X_train, y_train) # Fit the training data to the visualizer
visualizer.score(X_test, y_test) # Evaluate the model on the test data
visualizer.show() # Finalize and show the figure
Out[183]:
Extra¶
Esta parte sera dedicada para tentar criar uma tabela e comparar os diferentes tipos de algoritmos graficamente.
In [184]:
testarray = np.asarray(y_test)
In [185]:
DummyClassifier = DummyClassifier()
DummyClassifier.fit(X_train, y_train)
prev_DummyClassifier = DummyClassifier.predict(X_test)
In [186]:
grap_DummyClassifier = []
for w in range (len(testarray)):
if prev_DummyClassifier[w] == testarray[w]:
grap_DummyClassifier.append(0.2)
else:
grap_DummyClassifier.append(None)
In [187]:
LogisticRegression = LogisticRegression()
LogisticRegression.fit(X_train, y_train)
prev_LogisticRegression = LogisticRegression.predict(X_test)
In [188]:
grap_LogisticRegression = []
for w in range (len(testarray)):
if prev_LogisticRegression[w] == testarray[w]:
grap_LogisticRegression.append(0.4)
else:
grap_LogisticRegression.append(None)
In [189]:
DecisionTreeClassifier = DecisionTreeClassifier()
DecisionTreeClassifier.fit(X_train, y_train)
prev_DecisionTreeClassifier = DecisionTreeClassifier.predict(X_test)
In [190]:
grap_DecisionTreeClassifier = []
for w in range (len(testarray)):
if prev_DecisionTreeClassifier[w] == testarray[w]:
grap_DecisionTreeClassifier.append(0.6)
else:
grap_DecisionTreeClassifier.append(None)
In [191]:
KNeighborsClassifier = KNeighborsClassifier()
KNeighborsClassifier.fit(X_train, y_train)
prev_KNeighborsClassifier = KNeighborsClassifier.predict(X_test)
In [192]:
grap_KNeighborsClassifier = []
for w in range (len(testarray)):
if prev_KNeighborsClassifier[w] == testarray[w]:
grap_KNeighborsClassifier.append(0.8)
else:
grap_KNeighborsClassifier.append(None)
In [193]:
GaussianNB = GaussianNB()
GaussianNB.fit(X_train, y_train)
prev_GaussianNB = GaussianNB.predict(X_test)
In [194]:
grap_GaussianNB = []
for w in range (len(testarray)):
if prev_GaussianNB[w] == testarray[w]:
grap_GaussianNB.append(1)
else:
grap_GaussianNB.append(None)
In [195]:
RandomForestClassifier = RandomForestClassifier()
RandomForestClassifier.fit(X_train, y_train)
prev_RandomForestClassifier = RandomForestClassifier.predict(X_test)
In [196]:
grap_RandomForestClassifier = []
for w in range (len(testarray)):
if prev_RandomForestClassifier[w] == testarray[w]:
grap_RandomForestClassifier.append(1.2)
else:
grap_RandomForestClassifier.append(None)
In [197]:
SVC = SVC()
SVC.fit(X_train, y_train)
prev_SVC = SVC.predict(X_test)
In [198]:
grap_SVC = []
for w in range (len(testarray)):
if prev_SVC[w] == testarray[w]:
grap_SVC.append(1.4)
else:
grap_SVC.append(None)
In [199]:
Estrela = []
for x in range (len(grap_SVC)):
if grap_DummyClassifier[x] != None and grap_LogisticRegression[x] != None and grap_DecisionTreeClassifier[x] != None and grap_KNeighborsClassifier[x] != None and grap_GaussianNB[x] != None and grap_RandomForestClassifier[x] != None and grap_SVC[x] != None :
Estrela.append(1.6)
else:
Estrela.append(None)
In [200]:
plt.figure(figsize=(20,10))
x = np.arange(268)
plt.plot(x, grap_DummyClassifier, 'bo', label='DummyClassifier')
plt.plot(x, grap_LogisticRegression, 'ro', label='LogisticRegression')
plt.plot(x, grap_DecisionTreeClassifier, 'go', label='DecisionTreeClassifier')
plt.plot(x, grap_KNeighborsClassifier, 'co', label='KNeighborsClassifier')
plt.plot(x, grap_GaussianNB, 'yo', label='GaussianNB')
plt.plot(x, grap_RandomForestClassifier, 'mo', label='RandomForestClassifier')
plt.plot(x, grap_SVC, 'ko', label='SVC')
plt.plot(x, Estrela, 'y*', label='Todos Acertaram', markersize=12)
plt.title('Comparacao entre os modelos')
plt.legend(loc='upper center', bbox_to_anchor=(0.5, 0))
plt.rcParams.update({'font.size': 30})
In [201]:
In [ ]: